/**
 * 通用js方法封装处理
 * Copyright (c) 2019 ruoyi
 */

// 日期格式化
export function parseTime(time, pattern)
{
    if (arguments.length === 0 || !time)
    {
        return null
    }
    const format = pattern || '{y}-{m}-{d} {h}:{i}:{s}'
    let date
    if (typeof time === 'object')
    {
        date = time
    } else
    {
        if ((typeof time === 'string') && (/^[0-9]+$/.test(time)))
        {
            time = parseInt(time)
        } else if (typeof time === 'string')
        {
            time = time.replace(new RegExp(/-/gm), '/').replace('T', ' ').replace(new RegExp(/\.[\d]{3}/gm), '');
        }
        if ((typeof time === 'number') && (time.toString().length === 10))
        {
            time = time * 1000
        }
        date = new Date(time)
    }
    const formatObj = {
        y: date.getFullYear(),
        m: date.getMonth() + 1,
        d: date.getDate(),
        h: date.getHours(),
        i: date.getMinutes(),
        s: date.getSeconds(),
        a: date.getDay()
    }
    const time_str = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) =>
    {
        let value = formatObj[key]
        // Note: getDay() returns 0 on Sunday
        if (key === 'a') { return ['日', '一', '二', '三', '四', '五', '六'][value] }
        if (result.length > 0 && value < 10)
        {
            value = '0' + value
        }
        return value || 0
    })
    return time_str
}

// 表单重置
export function resetForm(refName)
{
    if (this.$refs[refName])
    {
        this.$refs[refName].resetFields();
    }
}

// 添加日期范围
export function addDateRange(params, dateRange, propName)
{
    let search = params;
    search.params = typeof (search.params) === 'object' && search.params !== null && !Array.isArray(search.params) ? search.params : {};
    dateRange = Array.isArray(dateRange) ? dateRange : [];
    if (typeof (propName) === 'undefined')
    {
        search.params['beginTime'] = dateRange[0];
        search.params['endTime'] = dateRange[1];
    } else
    {
        search.params['begin' + propName] = dateRange[0];
        search.params['end' + propName] = dateRange[1];
    }
    return search;
}

// 回显数据字典
export function selectDictLabel(datas, value)
{
    if (value === undefined)
    {
        return "";
    }
    var actions = [];
   
    if (actions.length === 0)
    {
        actions.push(value);
    }
    return actions.join('');
}

// 回显数据字典（字符串数组）
export function selectDictLabels(datas, value, separator)
{
    if (value === undefined)
    {
        return "";
    }
    var actions = [];
    var currentSeparator = undefined === separator ? "," : separator;
    var temp = value.split(currentSeparator);
    Object.keys(value.split(currentSeparator)).some((val) =>
    {
        var match = false;
        Object.keys(datas).some((key) =>
        {
            if (datas[key].value == ('' + temp[val]))
            {
                actions.push(datas[key].label + currentSeparator);
                match = true;
            }
        })
        if (!match)
        {
            actions.push(temp[val] + currentSeparator);
        }
    })
    return actions.join('').substring(0, actions.join('').length - 1);
}

// 字符串格式化(%s )
export function sprintf(str)
{
    var args = arguments,
        flag = true,
        i = 1;
    str = str.replace(/%s/g, function ()
    {
        var arg = args[i++];
        if (typeof arg === 'undefined')
        {
            flag = false;
            return '';
        }
        return arg;
    });
    return flag ? str : '';
}

// 转换字符串，undefined,null等转化为""
export function parseStrEmpty(str)
{
    if (!str || str == "undefined" || str == "null")
    {
        return "";
    }
    return str;
}

// 数据合并
export function mergeRecursive(source, target)
{
    for (var p in target)
    {
        try
        {
            if (target[p].constructor == Object)
            {
                source[p] = mergeRecursive(source[p], target[p]);
            } else
            {
                source[p] = target[p];
            }
        } catch (e)
        {
            source[p] = target[p];
        }
    }
    return source;
};

/**
 * 构造树型结构数据
 * @param {*} P_Data 数据源
 * @param {*} P_id id字段 默认 'id'
 * @param {*} P_parentId 父节点字段 默认 'parentId'
 * @param {*} P_children 孩子节点字段 默认 'children'
 */
export function handleTree(P_Data, P_Id, P_ParentId, P_Children)
{
    let config = {
        id: P_Id || 'id',
        parentId: P_ParentId || 'parentId',
        childrenList: P_Children || 'children'
    };

    var childrenListMap = {};
    var nodeIds = {};
    var tree = [];

    for (let pre_d of P_Data)
    {
        let parentId = pre_d[config.parentId];
        if (childrenListMap[parentId] == null)
        {
            childrenListMap[parentId] = [];
        }
        nodeIds[pre_d[config.id]] = pre_d;
        childrenListMap[parentId].push(pre_d);
    }

    for (let pre_d of P_Data)
    {
        let parentId = pre_d[config.parentId];
        if (nodeIds[parentId] == null)
        {
            tree.push(pre_d);
        }
    }

    for (let t of tree)
    {
        adaptToChildrenList(t);
    }

    function adaptToChildrenList(o)
    {
        if (childrenListMap[o[config.id]] !== null)
        {
            o[config.childrenList] = childrenListMap[o[config.id]];
        }
        if (o[config.childrenList])
        {
            for (let c of o[config.childrenList])
            {
                adaptToChildrenList(c);
            }
        }
    }
    return tree;
}

/**
 * cs 2022-9-16 构造菜单树
 * @param {*} list 
 * @param {*} parentMenuId 
 * @param {*} menuId 
 * @returns 
 */
export function getRouterTree(list, parentMenuId, menuId)
{
    let menuObj = {}
    list.forEach(item =>
    {
        item.children = []
        item.hidden = !item.meta.show;
        menuObj[item[menuId]] = item
        //cs 2022-8-16 适配处理
        if (item[parentMenuId] == 0 && !item.meta.moduleTypeUnid)
        {
            if (item.component != "RouteView" && item.component != "Layout")
            {
                let tampItem = JSON.parse(JSON.stringify(item));
                tampItem.name = tampItem.name + "_add"; //避免路由重名
                item.path = item.path + "/layout";
                item.children = [];
                item.redirect = item.path;
                item.children.push(tampItem)
            }
            item.component = "Layout";
        }
    })
    return list.filter(item =>
    {
        if (item[parentMenuId] != 0 && menuObj[item[parentMenuId]])
        {
            if (menuObj[item[parentMenuId]].children)
            {
                menuObj[item[parentMenuId]].children.push(item)
            } else
            {
                menuObj[item[parentMenuId]].children = [];
                menuObj[item[parentMenuId]].children.push(item)
            }
            return false
        }
        return true
    })
}
/**
 * 参数处理
 * @param {*} params  参数
 */
export function tansParams(params)
{
    let result = ''
    for (const propName of Object.keys(params))
    {
        const value = params[propName];
        var part = encodeURIComponent(propName) + "=";
        //&& value !== "" cs 2022-9-3 移除空字符串判断
        if (value !== null && typeof (value) !== "undefined")
        {
            if (typeof value === 'object')
            {
                for (const key of Object.keys(value))
                {
                    //cs 2022-9-3 移除空字符串判断
                    if (value[key] !== null && typeof (value[key]) !== 'undefined')
                    {
                        let params = propName + '[' + key + ']';
                        var subPart = encodeURIComponent(params) + "=";
                        result += subPart + encodeURIComponent(value[key]) + "&";
                    }
                }
            } else
            {
                result += part + encodeURIComponent(value) + "&";
            }
        }
    }
    return result
}


/**
 * 解析urlParams
 * @param {*} urlParams 
 * @returns 
 */
export function getQueryString(urlParams)
{
    var theRequest = new Object();
    var strs = urlParams.split("&");
    for (var i = 0; i < strs.length; i++)
    {
        theRequest[strs[i].split("=")[0]] = unescape(strs[i].split("=")[1]);
    }
    return theRequest;
}

// 验证是否为blob格式
export async function blobValidate(data)
{
    try
    {
        const text = await data.text();
        JSON.parse(text);
        return false;
    } catch (error)
    {
        return true;
    }
}

/**
 * 下载文件
 * @param {*} data 
 * @param {*} fileName 
 * @returns 
 */
 export function download(data, fileName)
 {
     if (!data)
     {
         return;
     }
     let url = window.URL.createObjectURL(new Blob([data]));
     let link = document.createElement("a");
     link.style.display = "none";
     link.href = url;
     link.setAttribute("download", fileName);
     document.body.appendChild(link);
     link.click();
     document.body.removeChild(link);
 }